ടോക്സ് ടെസ്റ്റിംഗ് ഓട്ടോമേഷൻ: ഗ്ലോബൽ ടീമുകൾക്കായുള്ള മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗിലേക്ക് ഒരു ആഴത്തിലുള്ള പഠനം

ഇന്നത്തെ ആഗോള സോഫ്റ്റ്‌വെയർ രംഗത്ത്, "ഇത് എന്റെ മെഷീനിൽ പ്രവർത്തിക്കുന്നു" എന്നത് ഒരു ഡെവലപ്പർ പഴഞ്ചൊല്ലിനെക്കാൾ ഉപരിയായി ഒരു പ്രധാന ബിസിനസ് അപകടസാധ്യതയാണ്. നിങ്ങളുടെ ഉപയോക്താക്കൾ, ക്ലയിന്റുകൾ, സഹകാരികൾ എന്നിവർ ലോകമെമ്പാടും വ്യാപിച്ചു കിടക്കുന്നു, അവർ വിവിധ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ, പൈത്തൺ പതിപ്പുകൾ, ഡിപെൻഡൻസി സ്റ്റാക്കുകൾ എന്നിവ ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ കോഡ് പ്രവർത്തനക്ഷമമാണെന്ന് മാത്രമല്ല, എല്ലാവർക്കും, എല്ലായിടത്തും വിശ്വസനീയമായി ശക്തമാണെന്ന് നിങ്ങൾക്ക് എങ്ങനെ ഉറപ്പാക്കാൻ കഴിയും?

ചിട്ടയായ, ഓട്ടോമേറ്റഡ്, മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗിലാണ് ഇതിനുള്ള ഉത്തരം. ഇവിടെയാണ് കമാൻഡ്-ലൈൻ-ഡ്രൈവൻ ഓട്ടോമേഷൻ ടൂളായ Tox, ആധുനിക പൈത്തൺ ഡെവലപ്പറുടെ ടൂൾകിറ്റിന്റെ ഒഴിച്ചുകൂടാനാവാത്ത ഭാഗമായി മാറുന്നത്. ഇത് ടെസ്റ്റിംഗിനെ സാധാരണമാക്കുകയും, ഒരൊറ്റ കമാൻഡ് ഉപയോഗിച്ച് കോൺഫിഗറേഷനുകളുടെ ഒരു മാട്രിക്സിലുടനീളം ടെസ്റ്റുകൾ നിർവചിക്കാനും എക്സിക്യൂട്ട് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്നു.

ഈ സമഗ്രമായ ഗൈഡ്, ടോക്സിന്റെ അടിസ്ഥാനകാര്യങ്ങളിൽ നിന്ന് മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗിനായുള്ള വിപുലമായ തന്ത്രങ്ങളിലേക്ക് നിങ്ങളെ കൊണ്ടുപോകും. നിങ്ങളുടെ സോഫ്റ്റ്‌വെയർ അനുയോജ്യവും, സുസ്ഥിരവുമാണെന്നും, ഒരു ആഗോള പ്രേക്ഷകരെ ലക്ഷ്യമിട്ടുള്ളതാണെന്നും ഉറപ്പാക്കുന്ന ഒരു ശക്തമായ ടെസ്റ്റിംഗ് പൈപ്പ്ലൈൻ എങ്ങനെ നിർമ്മിക്കാമെന്ന് നമ്മുക്ക് പഠിക്കാം.

എന്താണ് മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗ്, എന്തുകൊണ്ട് ഇത് നിർണായകമാണ്?

ഒന്നിലധികം വ്യത്യസ്ത കോൺഫിഗറേഷനുകൾക്കെതിരെ നിങ്ങളുടെ ടെസ്റ്റ് സ്യൂട്ട് പ്രവർത്തിപ്പിക്കുന്ന രീതിയാണ് മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗ്. ഈ കോൺഫിഗറേഷനുകൾ, അല്ലെങ്കിൽ "എൻവയൺമെന്റുകൾ", സാധാരണയായി ഇനി പറയുന്നവയിൽ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു:

• പൈത്തൺ ഇന്റർപ്രെറ്റർ പതിപ്പുകൾ: നിങ്ങളുടെ കോഡ് പൈത്തൺ 3.8-ൽ പ്രവർത്തിക്കുന്നത് പോലെ തന്നെ പൈത്തൺ 3.11-ലും പ്രവർത്തിക്കുമോ? വരാനിരിക്കുന്ന പൈത്തൺ 3.12-നെക്കുറിച്ച് എന്ത് പറയുന്നു?
• ഡിപെൻഡൻസി പതിപ്പുകൾ: നിങ്ങളുടെ ആപ്ലിക്കേഷൻ Django, Pandas, അല്ലെങ്കിൽ Requests പോലുള്ള ലൈബ്രറികളെ ആശ്രയിച്ചേക്കാം. ഒരു ഉപയോക്താവിന് ഈ പാക്കേജുകളുടെ പഴയതോ പുതിയതോ ആയ പതിപ്പ് ഉണ്ടെങ്കിൽ അത് തകരുമോ?
• ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ: നിങ്ങളുടെ കോഡ് Windows, macOS, Linux എന്നിവയിൽ ഫയൽ പാതകളും സിസ്റ്റം കോളുകളും ശരിയായി കൈകാര്യം ചെയ്യുന്നുണ്ടോ?
• ആർക്കിടെക്ചറുകൾ: ARM അടിസ്ഥാനമാക്കിയുള്ള പ്രോസസ്സറുകളുടെ (Apple Silicon പോലെ) വർദ്ധനവിനനുസരിച്ച്, വ്യത്യസ്ത CPU ആർക്കിടെക്ചറുകളിൽ (x86_64, arm64) ടെസ്റ്റ് ചെയ്യുന്നത് കൂടുതൽ പ്രധാനമായി മാറുകയാണ്.

ഒരു മൾട്ടി-എൻവയൺമെന്റ് സ്ട്രാറ്റജിക്കായുള്ള ബിസിനസ് കേസ്

ഇത്തരത്തിലുള്ള ടെസ്റ്റിംഗ് സജ്ജീകരിക്കുന്നതിന് സമയം നിക്ഷേപിക്കുന്നത് വെറുമൊരു അക്കാദമിക് വ്യായാമം മാത്രമല്ല; ഇതിന് നേരിട്ട് ബിസിനസ്പരമായ ബന്ധങ്ങളുണ്ട്:

• സപ്പോർട്ട് ചിലവുകൾ കുറയ്ക്കുന്നു: അനുയോജ്യത പ്രശ്നങ്ങൾ നേരത്തേ കണ്ടെത്തുന്നതിലൂടെ, നിങ്ങൾ പ്രതീക്ഷിക്കാത്ത എൻവയൺമെന്റുകളിൽ നിന്നുള്ള ഉപയോക്താക്കളുടെ സപ്പോർട്ട് ടിക്കറ്റുകളുടെ പ്രളയം തടയാൻ കഴിയും.
• ഉപയോക്താക്കളുടെ വിശ്വാസം വർദ്ധിപ്പിക്കുന്നു: വ്യത്യസ്ത സജ്ജീകരണങ്ങളിൽ വിശ്വസനീയമായി പ്രവർത്തിക്കുന്ന സോഫ്റ്റ്‌വെയർ ഉയർന്ന നിലവാരമുള്ളതായി കണക്കാക്കപ്പെടുന്നു. ഓപ്പൺ സോഴ്സ് ലൈബ്രറികൾക്കും കൊമേർഷ്യൽ ഉൽപ്പന്നങ്ങൾക്കും ഇത് നിർണായകമാണ്.
• സുഗമമായ നവീകരണങ്ങൾ സാധ്യമാക്കുന്നു: ഒരു പുതിയ പൈത്തൺ പതിപ്പ് പുറത്തിറങ്ങുമ്പോൾ, നിങ്ങൾക്ക് ഇത് നിങ്ങളുടെ ടെസ്റ്റ് മാട്രിക്സിലേക്ക് എളുപ്പത്തിൽ ചേർക്കാൻ കഴിയും. ടെസ്റ്റുകൾ വിജയിക്കുകയാണെങ്കിൽ, നിങ്ങൾ അതിനെ പിന്തുണയ്ക്കാൻ തയ്യാറാണെന്ന് നിങ്ങൾക്കറിയാം. അവ പരാജയപ്പെട്ടാൽ, എന്താണ് പരിഹരിക്കേണ്ടതെന്ന് വ്യക്തമായ ഒരു ലിസ്റ്റ് നിങ്ങളുടെ പക്കലുണ്ടാകും.
• ആഗോള ടീമുകളെ പിന്തുണയ്ക്കുന്നു: ഏറ്റവും പുതിയ ടൂളുകൾ ഉപയോഗിക്കുന്ന ഒരു രാജ്യത്തിലെ ഒരു ഡെവലപ്പർക്ക്, ഒരു സ്റ്റാൻഡേർഡ്, പഴയ എന്റർപ്രൈസ് സ്റ്റാക്കിലുള്ള മറ്റൊരു പ്രദേശത്തെ ടീമുമായി ഫലപ്രദമായി സഹകരിക്കാൻ കഴിയുമെന്ന് ഇത് ഉറപ്പാക്കുന്നു.

Tox-ലേക്ക് പരിചയപ്പെടുത്തുന്നു: നിങ്ങളുടെ ഓട്ടോമേഷൻ കമാൻഡ് സെന്റർ

ഈ പ്രശ്നം മനോഹരമായി പരിഹരിക്കാൻ Tox രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. Tox-ന്റെ പ്രധാന ലക്ഷ്യം ഒറ്റപ്പെട്ട പൈത്തൺ വെർച്വൽ എൻവയൺമെന്റുകൾ നിർമ്മിക്കുകയും, നിങ്ങളുടെ പ്രോജക്റ്റും അതിന്റെ ഡിപെൻഡൻസികളും ഇൻസ്റ്റാൾ ചെയ്യുകയും, തുടർന്ന് നിങ്ങളുടെ നിർവചിക്കപ്പെട്ട കമാൻഡുകൾ (ടെസ്റ്റുകൾ, ലിന്ററുകൾ അല്ലെങ്കിൽ ഡോക്യുമെന്റേഷൻ ബിൽഡുകൾ പോലെ) പ്രവർത്തിപ്പിക്കുകയും ചെയ്യുന്നു.

ഇവയെല്ലാം ഒരൊറ്റ, ലളിതമായ കോൺഫിഗറേഷൻ ഫയൽ ഉപയോഗിച്ച് നിയന്ത്രിക്കുന്നു: tox.ini.

ആരംഭിക്കുന്നു: ഇൻസ്റ്റാളേഷനും അടിസ്ഥാന കോൺഫിഗറേഷനും

pip ഉപയോഗിച്ച് ഇൻസ്റ്റാൾ ചെയ്യുന്നത് എളുപ്പമാണ്:

pip install tox

അടുത്തതായി, നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ റൂട്ടിൽ ഒരു tox.ini ഫയൽ ഉണ്ടാക്കുക. ഒന്നിലധികം പൈത്തൺ പതിപ്പുകൾക്കെതിരെ ടെസ്റ്റ് ചെയ്യുന്നതിനുള്ള ഏറ്റവും കുറഞ്ഞ കോൺഫിഗറേഷനിൽ നിന്ന് നമുക്ക് ആരംഭിക്കാം.

ഉദാഹരണം: ഒരു അടിസ്ഥാന tox.ini

[tox]
min_version = 3.7
isolated_build = true
envlist = py38, py39, py310, py311

[testenv]
description = Run the main test suite
deps = pytest
commands = pytest

ഇതിനെക്കുറിച്ച് വിശദമായി നോക്കാം:

• [tox] വിഭാഗം: ഇത് ആഗോള Tox ക്രമീകരണങ്ങൾക്കുള്ളതാണ്.
• min_version: ഈ കോൺഫിഗറേഷൻ പ്രവർത്തിപ്പിക്കാൻ ആവശ്യമായ Tox-ന്റെ ഏറ്റവും കുറഞ്ഞ പതിപ്പ് വ്യക്തമാക്കുന്നു.
• isolated_build: ടെസ്റ്റിംഗിനായി ഇൻസ്റ്റാൾ ചെയ്യുന്നതിനുമുമ്പ് നിങ്ങളുടെ പാക്കേജ് ഒരു ഒറ്റപ്പെട്ട എൻവയൺമെന്റിൽ നിർമ്മിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്ന ഒരു ആധുനിക രീതിയാണിത് (PEP 517).
• envlist: ഇതാണ് മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗിന്റെ ഹൃദയം. Tox കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന എൻവയൺമെന്റുകളുടെ കോമ ഉപയോഗിച്ച് വേർതിരിച്ച ലിസ്റ്റാണിത്. ഇവിടെ, ഞങ്ങൾ നാലെണ്ണം നിർവചിച്ചിരിക്കുന്നു: 3.8 മുതൽ 3.11 വരെയുള്ള ഓരോ പൈത്തൺ പതിപ്പിനും ഓരോന്ന്.
• [testenv] വിഭാഗം: envlist-ൽ നിർവചിച്ചിട്ടുള്ള എല്ലാ എൻവയൺമെന്റുകൾക്കുമുള്ള ഒരു ടെംപ്ലേറ്റ് ആണിത്.
• description: എൻവയൺമെന്റ് എന്താണ് ചെയ്യുന്നതെന്ന് വിശദീകരിക്കുന്ന ഒരു സഹായകരമായ സന്ദേശം.
• deps: നിങ്ങളുടെ കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാൻ ആവശ്യമായ ഡിപെൻഡൻസികളുടെ ഒരു ലിസ്റ്റ്. ഇവിടെ, ഞങ്ങൾക്ക് pytest മാത്രം മതി.
• commands: വെർച്വൽ എൻവയൺമെന്റിനുള്ളിൽ എക്സിക്യൂട്ട് ചെയ്യേണ്ട കമാൻഡുകൾ. ഇവിടെ, ഞങ്ങൾ pytest ടെസ്റ്റ് റണ്ണർ പ്രവർത്തിപ്പിക്കുന്നു.

ഇത് പ്രവർത്തിപ്പിക്കാൻ, നിങ്ങളുടെ ടെർമിനലിൽ നിങ്ങളുടെ പ്രോജക്റ്റിന്റെ റൂട്ട് ഡയറക്ടറിയിലേക്ക് നാവിഗേറ്റ് ചെയ്ത് ടൈപ്പ് ചെയ്യുക:

tox

ഇപ്പോൾ Tox `envlist`-ലെ (py38, py39, മുതലായവ) ഓരോ എൻവയൺമെന്റിനുമായി താഴെ പറയുന്ന കാര്യങ്ങൾ ചെയ്യും:

1. നിങ്ങളുടെ സിസ്റ്റത്തിൽ ബന്ധപ്പെട്ട പൈത്തൺ ഇന്റർപ്രെറ്റർക്കായി തിരയുക (ഉദാഹരണത്തിന്, `python3.8`, `python3.9`).
2. .tox/ ഡയറക്ടറിക്കുള്ളിൽ പുതിയതും ഒറ്റപ്പെട്ടതുമായ വെർച്വൽ എൻവയൺമെന്റ് ഉണ്ടാക്കുക.
3. നിങ്ങളുടെ പ്രോജക്റ്റും `deps`-ൽ ലിസ്റ്റ് ചെയ്തിട്ടുള്ള ഡിപെൻഡൻസികളും ഇൻസ്റ്റാൾ ചെയ്യുക.
4. `commands`-ൽ ലിസ്റ്റ് ചെയ്തിട്ടുള്ള കമാൻഡുകൾ എക്സിക്യൂട്ട് ചെയ്യുക.

ഏതെങ്കിലും എൻവയൺമെന്റിൽ ഏതെങ്കിലും ഘട്ടം പരാജയപ്പെട്ടാൽ, Tox പിശക് റിപ്പോർട്ട് ചെയ്യുകയും പൂജ്യമല്ലാത്ത സ്റ്റാറ്റസ് കോഡ് ഉപയോഗിച്ച് എക്സിറ്റ് ചെയ്യുകയും ചെയ്യും, ഇത് കണ്ടിന്യൂവസ് ഇന്റഗ്രേഷൻ (CI) സിസ്റ്റങ്ങൾക്ക് അനുയോജ്യമാക്കുന്നു.

ആഴത്തിലുള്ള പഠനം: ശക്തമായ ഒരു tox.ini ഉണ്ടാക്കുന്നു

അടിസ്ഥാന സജ്ജീകരണം ശക്തമാണ്, എന്നാൽ Tox-ന്റെ യഥാർത്ഥ മാന്ത്രികം സങ്കീർണ്ണമായ ടെസ്റ്റ് മാട്രിക്സുകൾ നിർമ്മിക്കുന്നതിനുള്ള ഫ്ലെക്സിബിൾ കോൺഫിഗറേഷൻ ഓപ്ഷനുകളിലാണ്.

ജെനറേറ്റീവ് എൻവയൺമെന്റുകൾ: കോമ്പിനേറ്റോറിയൽ ടെസ്റ്റിംഗിന്റെ താക്കോൽ

നിങ്ങളുടെ ലൈബ്രറി പൈത്തൺ 3.9-ലും 3.10-ലും പ്രവർത്തിക്കുന്ന Django പതിപ്പുകൾ 3.2, 4.2 എന്നിവയെ പിന്തുണയ്ക്കേണ്ടതുണ്ടെന്ന് കരുതുക. നാല് കോമ്പിനേഷനുകളും സ്വമേധയാ നിർവചിക്കുന്നത് ആവർത്തനപരമായിരിക്കും:

ആവർത്തനപരമായ വഴി: envlist = py39-django32, py39-django42, py310-django32, py310-django42

Tox ചുരുളൻ ബ്രാക്കറ്റുകൾ {} ഉപയോഗിച്ച് വളരെ എളുപ്പവും ജനറേറ്റീവുമായ വാക്യഘടന നൽകുന്നു:

ജനറേറ്റീവ് വഴി: envlist = {py39,py310}-django{32,42}

ഈ ഒരൊറ്റ ലൈൻ അതേ നാല് എൻവയൺമെന്റുകളിലേക്ക് വികസിക്കുന്നു. ഈ രീതി വളരെ വലുതാക്കാവുന്നതാണ്. ഒരു പുതിയ പൈത്തൺ പതിപ്പോ Django പതിപ്പോ ചേർക്കുന്നത് അതത് ലിസ്റ്റിലേക്ക് ഒരു ഐറ്റം ചേർക്കുന്ന പ്രശ്നം മാത്രമേയുള്ളു.

ഫാക്ടർ-കണ്ടീഷണൽ ക്രമീകരണങ്ങൾ: ഓരോ എൻവയൺമെന്റും ഇഷ്ടാനുസൃതമാക്കുന്നു

ഇപ്പോൾ നമ്മൾ നമ്മുടെ മാട്രിക്സ് നിർവചിച്ചു, ഓരോ എൻവയൺമെന്റിലും ശരിയായ Django പതിപ്പ് ഇൻസ്റ്റാൾ ചെയ്യാൻ Tox-നോട് നമ്മൾ എങ്ങനെ പറയും? ഇത് ഫാക്ടർ-കണ്ടീഷണൽ ക്രമീകരണങ്ങൾ ഉപയോഗിച്ചാണ് ചെയ്യുന്നത്.

[tox]
envlist = {py39,py310}-django{32,42}

[testenv]
deps =
    pytest
    django32: Django>=3.2,<3.3
    django42: Django>=4.2,<4.3
commands = pytest

ഇവിടെ, `django32: Django>=3.2,<3.3` എന്ന ലൈൻ Tox-നോട് പറയുന്നു: "എൻവയൺമെന്റിന്റെ പേരിൽ `django32` എന്ന ഫാക്ടർ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ മാത്രം ഈ ഡിപെൻഡൻസി ഉൾപ്പെടുത്തുക." അതുപോലെ `django42`-നും. Tox എൻവയൺമെന്റിന്റെ പേരുകൾ (ഉദാഹരണത്തിന്, `py310-django42`) ശരിയായി വായിക്കാനും ശരിയായ ക്രമീകരണങ്ങൾ പ്രയോഗിക്കാനും മതിയായ കഴിവുള്ളതാണ്.

ഇനി പറയുന്നവ കൈകാര്യം ചെയ്യുന്നതിന് ഇത് വളരെ ശക്തമായ സവിശേഷതയാണ്:

• പഴയ/പുതിയ പൈത്തൺ പതിപ്പുകളുമായി പൊരുത്തമില്ലാത്ത ഡിപെൻഡൻസികൾ.
• ഒരു കോർ ലൈബ്രറിയുടെ വ്യത്യസ്ത പതിപ്പുകൾക്കെതിരെ ടെസ്റ്റ് ചെയ്യുന്നു (Pandas, NumPy, SQLAlchemy, തുടങ്ങിയവ).
• പ്ലാറ്റ്‌ഫോമിന് മാത്രമായുള്ള ഡിപെൻഡൻസികളുടെ കണ്ടീഷണൽ ഇൻസ്റ്റാളേഷൻ.

അടിസ്ഥാന ടെസ്റ്റുകൾക്കപ്പുറം നിങ്ങളുടെ പ്രോജക്റ്റ് ക്രമീകരിക്കുന്നു

ശക്തമായ ഒരു ക്വാളിറ്റി പൈപ്പ്ലൈനിൽ ടെസ്റ്റുകൾ പ്രവർത്തിപ്പിക്കുന്നതിലുമധികം കാര്യങ്ങൾ ഉൾപ്പെടുന്നു. നിങ്ങൾ ലിന്ററുകൾ പ്രവർത്തിപ്പിക്കുകയും, ടൈപ്പ് ചെക്കറുകൾ പ്രവർത്തിപ്പിക്കുകയും, ഡോക്യുമെന്റേഷൻ ഉണ്ടാക്കുകയും വേണം. ഈ ടാസ്‌ക്കുകൾക്കായി പ്രത്യേക Tox എൻവയൺമെന്റുകൾ നിർവചിക്കുന്നത് നല്ലതാണ്.

[tox]
envlist = py{39,310}, lint, typing, docs

[testenv]
deps = pytest
commands = pytest

[testenv:lint]
description = Run linters (ruff, black)
basepython = python3.10
deps =
    ruff
    black
commands =
    ruff check .
    black --check .

[testenv:typing]
description = Run static type checker (mypy)
basepython = python3.10
deps =
    mypy
    # also include other dependencies with type hints
    django
    djangorestframework
commands = mypy my_project/

[testenv:docs]
description = Build the documentation
basepython = python3.10
deps = sphinx
commands = sphinx-build -b html docs/source docs/build/html

ഇവിടെ പുതിയതായി എന്താണുള്ളത്:

• പ്രത്യേക എൻവയൺമെന്റ് വിഭാഗങ്ങൾ: ഞങ്ങൾ `[testenv:lint]`, `[testenv:typing]`, കൂടാതെ `[testenv:docs]` എന്നിവ ചേർത്തിട്ടുണ്ട്. ഈ വിഭാഗങ്ങൾ `[testenv]`-ലെ സ്ഥിരമായ ക്രമീകരണങ്ങളെ മറികടന്ന്, ആ പേരുള്ള എൻവയൺമെന്റുകൾക്കായി പ്രത്യേകമായി ക്രമീകരണങ്ങൾ നിർവചിക്കുന്നു.
• basepython: `lint` അല്ലെങ്കിൽ `docs` പോലുള്ള ടെസ്റ്റ് ചെയ്യാത്ത എൻവയൺമെന്റുകൾക്കായി, നമ്മൾ അവയെ എല്ലാ പൈത്തൺ പതിപ്പുകളിലും പ്രവർത്തിപ്പിക്കേണ്ടതില്ല. `basepython` ഒരു പ്രത്യേക ഇന്റർപ്രെറ്ററിലേക്ക് അവയെ പിൻ ചെയ്യാൻ ഞങ്ങളെ അനുവദിക്കുന്നു, ഇത് അവയെ വേഗത്തിലാക്കുകയും കൂടുതൽ കൃത്യതയുള്ളതാക്കുകയും ചെയ്യുന്നു.
• കൃത്യമായ വേർതിരിവ്: ഈ ഘടന നിങ്ങളുടെ ഡിപെൻഡൻസികളെ വൃത്തിയായി സൂക്ഷിക്കുന്നു. `lint` എൻവയൺമെന്റ് ലിന്ററുകൾ മാത്രമേ ഇൻസ്റ്റാൾ ചെയ്യുന്നുള്ളൂ; നിങ്ങളുടെ പ്രധാന ടെസ്റ്റ് എൻവയൺമെന്റുകൾക്ക് അവ ആവശ്യമില്ല.

നിങ്ങൾക്ക് ഇപ്പോൾ `tox` ഉപയോഗിച്ച് എല്ലാ എൻവയൺമെന്റുകളും, `tox -e py310,lint` ഉപയോഗിച്ച് ഒരു പ്രത്യേക സെറ്റും, അല്ലെങ്കിൽ `tox -e docs` ഉപയോഗിച്ച് ഒരെണ്ണം മാത്രം പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

ആഗോളതലത്തിലുള്ള ഓട്ടോമേഷനായി CI/CD-യുമായി Tox-നെ സംയോജിപ്പിക്കുന്നു

Tox ലോക്കലായി പ്രവർത്തിപ്പിക്കുന്നത് മികച്ചതാണ്, എന്നാൽ കണ്ടിന്യൂവസ് ഇന്റഗ്രേഷൻ/കണ്ടിന്യൂവസ് ഡെപ്ലോയ്‌മെന്റ് (CI/CD) പൈപ്പ്ലൈനിലേക്ക് സംയോജിപ്പിക്കുമ്പോൾ അതിന്റെ യഥാർത്ഥ ശക്തി പുറത്തുവരുന്നു. എല്ലാ കോഡ് മാറ്റങ്ങളും നിങ്ങളുടെ പൂർണ്ണമായ ടെസ്റ്റ് മാട്രിക്സിനെതിരെ സ്വയമേവ സാധൂകരിക്കപ്പെടുന്നുവെന്ന് ഇത് ഉറപ്പാക്കുന്നു.

GitHub Actions, GitLab CI, Jenkins തുടങ്ങിയ സേവനങ്ങൾ ഇതിന് അനുയോജ്യമാണ്. വ്യത്യസ്ത ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ നിങ്ങളുടെ ജോലികൾ പ്രവർത്തിപ്പിക്കാൻ അവയ്ക്ക് കഴിയും, ഇത് OS അനുയോജ്യതയുടെ ഒരു സമഗ്രമായ മാട്രിക്സ് നിർമ്മിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: ഒരു GitHub Actions വർക്ക്ഫ്ലോ

Linux, macOS, Windows എന്നിവയിലുടനീളം ഞങ്ങളുടെ Tox എൻവയൺമെന്റുകൾ സമാന്തരമായി പ്രവർത്തിപ്പിക്കുന്ന ഒരു GitHub Actions വർക്ക്ഫ്ലോ ഉണ്ടാക്കാം.

.github/workflows/ci.yml-ൽ ഒരു ഫയൽ ഉണ്ടാക്കുക:

name: CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest, windows-latest]
        python-version: ['3.8', '3.9', '3.10', '3.11']

    steps:
    - name: Check out repository
      uses: actions/checkout@v3

    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v4
      with:
        python-version: ${{ matrix.python-version }}

    - name: Install Tox
      run: pip install tox tox-gh-actions

    - name: Run Tox
      run: tox -e py

ഈ വർക്ക്ഫ്ലോയെ നമുക്ക് വിശകലനം ചെയ്യാം:

• strategy.matrix: ഇതാണ് ഞങ്ങളുടെ CI മാട്രിക്സിന്റെ കാതൽ. GitHub Actions, `os`-ന്റെയും `python-version`-ന്റെയും ഓരോ കോമ്പിനേഷനും പ്രത്യേകം ജോലികൾ ഉണ്ടാക്കും. ഈ കോൺഫിഗറേഷനായി, അത് 3 ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ × 4 പൈത്തൺ പതിപ്പുകൾ = 12 സമാന്തര ജോലികൾ ആണ്.
• actions/setup-python@v4: ഓരോ ജോലിക്കും ആവശ്യമായ പ്രത്യേക പൈത്തൺ പതിപ്പ് സജ്ജീകരിക്കുന്നതിനുള്ള സാധാരണ ആക്ഷനാണിത്.
• tox-gh-actions: CI എൻവയൺമെന്റിലെ പൈത്തൺ പതിപ്പിനെ ശരിയായ Tox എൻവയൺമെന്റിലേക്ക് സ്വയമേവ മാപ്പ് ചെയ്യുന്ന ഒരു സഹായകരമായ Tox പ്ലഗിൻ ആണിത്. ഉദാഹരണത്തിന്, പൈത്തൺ 3.9-ൽ പ്രവർത്തിക്കുന്ന ജോലിയിൽ, `tox -e py` സ്വയമേവ `tox -e py39` പ്രവർത്തിപ്പിക്കുന്നതിലേക്ക് മാറും. ഇത് നിങ്ങളുടെ CI സ്ക്രിപ്റ്റിൽ സങ്കീർണ്ണമായ ലോജിക് എഴുതുന്നതിൽ നിന്ന് നിങ്ങളെ രക്ഷിക്കുന്നു.

ഇപ്പോൾ, കോഡ് പുഷ് ചെയ്യുമ്പോഴെല്ലാം, നിങ്ങളുടെ മുഴുവൻ ടെസ്റ്റ് മാട്രിക്സും പ്രധാനപ്പെട്ട മൂന്ന് ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും സ്വയമേവ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നു. ഒരു മാറ്റം അനുയോജ്യമല്ലാത്ത എന്തെങ്കിലും അവതരിപ്പിച്ചിട്ടുണ്ടോ എന്നതിനെക്കുറിച്ച് നിങ്ങൾക്ക് ഉടനടി ഫീഡ്‌ബാക്ക് ലഭിക്കുന്നു, ഇത് ആഗോള ഉപയോക്താക്കൾക്കായി ആത്മവിശ്വാസത്തോടെ നിർമ്മിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

വിപുലമായ തന്ത്രങ്ങളും മികച്ച രീതികളും

{posargs} ഉപയോഗിച്ച് കമാൻഡുകളിലേക്ക് ആർഗ്യുമെന്റുകൾ കൈമാറുന്നു

ചില സമയങ്ങളിൽ നിങ്ങളുടെ ടെസ്റ്റ് റണ്ണറിലേക്ക് കൂടുതൽ ആർഗ്യുമെന്റുകൾ കൈമാറേണ്ടി വന്നേക്കാം. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു പ്രത്യേക ടെസ്റ്റ് ഫയൽ പ്രവർത്തിപ്പിക്കാൻ ആഗ്രഹമുണ്ടാകാം: pytest tests/test_api.py. Tox ഇതിനെ {posargs} സബ്സ്റ്റിറ്റ്യൂഷൻ ഉപയോഗിച്ച് പിന്തുണയ്ക്കുന്നു.

നിങ്ങളുടെ `tox.ini` മാറ്റുക:

[testenv]
deps = pytest
commands = pytest {posargs}

ഇപ്പോൾ, നിങ്ങൾക്ക് Tox ഇങ്ങനെ പ്രവർത്തിപ്പിക്കാൻ കഴിയും:

tox -e py310 -- -k "test_login" -v

Tox-നുള്ള ആർഗ്യുമെന്റുകളും കമാൻഡിനുള്ള ആർഗ്യുമെന്റുകളും -- ഉപയോഗിച്ച് വേർതിരിക്കുന്നു. അതിനുശേഷമുള്ളതെല്ലാം `{posargs}`-നായി മാറ്റും. Tox `py310` എൻവയൺമെന്റിനുള്ളിൽ pytest -k "test_login" -v എക്സിക്യൂട്ട് ചെയ്യും.

എൻവയൺമെന്റ് വേരിയബിളുകൾ നിയന്ത്രിക്കുന്നു

എൻവയൺമെന്റ് വേരിയബിളുകളെ അടിസ്ഥാനമാക്കി നിങ്ങളുടെ ആപ്ലിക്കേഷൻ വ്യത്യസ്തമായി പ്രവർത്തിച്ചേക്കാം (ഉദാഹരണത്തിന്, `DJANGO_SETTINGS_MODULE`). `setenv` നിർദ്ദേശം നിങ്ങളുടെ Tox എൻവയൺമെന്റുകളിൽ ഇവ നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

[testenv]
setenv =
    PYTHONPATH = .
    MYAPP_MODE = testing

[testenv:docs]
setenv =
    SPHINX_BUILD = 1

വേഗത്തിലുള്ള Tox റണ്ണുകൾക്കുള്ള നുറുങ്ങുകൾ

നിങ്ങളുടെ മാട്രിക്സ് വലുതാകുമ്പോൾ, Tox റണ്ണുകൾക്ക് വേഗത കുറഞ്ഞേക്കാം. അവ വേഗത്തിലാക്കാൻ സഹായിക്കുന്ന ചില നുറുങ്ങുകൾ ഇതാ:

• പാരലൽ മോഡ്: Tox നിങ്ങളുടെ എൻവയൺമെന്റുകൾ സമാന്തരമായി പ്രവർത്തിപ്പിക്കാൻ `tox -p auto` റൺ ചെയ്യുക, ലഭ്യമായ CPU കോറുകളുടെ എണ്ണം ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കാൻ കഴിയും. ആധുനിക മെഷീനുകളിൽ ഇത് വളരെ ഫലപ്രദമാണ്.
• എൻവയൺമെന്റുകൾ സെലക്ടീവായി വീണ്ടും ഉണ്ടാക്കുക: സ്ഥിരമായി Tox എൻവയൺമെന്റുകൾ വീണ്ടും ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ ഡിപെൻഡൻസികൾ `tox.ini`-യിലോ `requirements.txt`-യിലോ മാറുകയാണെങ്കിൽ, എൻവയൺമെന്റ് ആദ്യം മുതൽ വീണ്ടും നിർമ്മിക്കാൻ Tox-നോട് പറയേണ്ടിവരും. അതിനായി `tox -r -e py310` ഫ്ലാഗ് ഉപയോഗിക്കുക.
• CI കാഷിംഗ്: നിങ്ങളുടെ CI/CD പൈപ്പ്ലൈനിൽ, .tox/ ഡയറക്ടറി കാഷ് ചെയ്യുക. ഇത് തുടർന്നുള്ള റണ്ണുകളുടെ വേഗത ഗണ്യമായി വർദ്ധിപ്പിക്കും, കാരണം ഡിപെൻഡൻസികൾ മാറിയിട്ടില്ലെങ്കിൽ ഓരോ തവണയും ഡൗൺലോഡ് ചെയ്ത് ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല.

പ്രാക്ടീസിലുള്ള ആഗോള ഉപയോഗ കേസുകൾ

ആഗോള സാഹചര്യത്തിൽ ഇത് എങ്ങനെ വ്യത്യസ്ത തരം പ്രോജക്റ്റുകൾക്ക് ബാധകമാണെന്ന് നമുക്ക് നോക്കാം.

Scenario 1: ഒരു ഓപ്പൺ സോഴ്സ് ഡാറ്റ അനാലിസിസ് ലൈബ്രറി

നിങ്ങൾ Pandas-ലും NumPy-യിലും നിർമ്മിച്ച ഒരു ജനപ്രിയ ലൈബ്രറി പരിപാലിക്കുന്നു. നിങ്ങളുടെ ഉപയോക്താക്കൾ ലോകമെമ്പാടുമുള്ള ഡാറ്റാ സയന്റിസ്റ്റുകളും അനലിസ്റ്റുകളുമാണ്.

• വെല്ലുവിളി: നിങ്ങൾ ഒന്നിലധികം പൈത്തൺ, Pandas, NumPy പതിപ്പുകളെ പിന്തുണയ്ക്കുകയും ഇത് Linux സെർവറുകൾ, macOS ലാപ്ടോപ്പുകൾ, Windows ഡെസ്ക്ടോപ്പുകൾ എന്നിവയിൽ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുകയും വേണം.
• Tox പരിഹാരം: envlist = {py39,py310,py311}-{pandas1,pandas2}-{numpy18,numpy19} നിങ്ങളുടെ `tox.ini` ഓരോ എൻവയൺമെന്റിനുമുള്ള ശരിയായ ലൈബ്രറി പതിപ്പുകൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഫാക്ടർ-കണ്ടീഷണൽ ക്രമീകരണങ്ങൾ ഉപയോഗിക്കും. നിങ്ങളുടെ GitHub Actions വർക്ക്ഫ്ലോ ഈ മാട്രിക്സ് എല്ലാ പ്രധാന ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും ടെസ്റ്റ് ചെയ്യും. പഴയ Pandas പതിപ്പ് ഉപയോഗിക്കുന്ന ബ്രസീലിലെ ഒരു ഉപയോക്താവിന് ഏറ്റവും പുതിയ സ്റ്റാക്കിലുള്ള ജപ്പാനിലെ ഒരു ഉപയോക്താവിന് ലഭിക്കുന്ന അതേ വിശ്വസനീയമായ അനുഭവം ലഭിക്കുമെന്ന് ഇത് ഉറപ്പാക്കുന്നു.

Scenario 2: ഒരു ക്ലയിന്റ് ലൈബ്രറിയുള്ള ഒരു എന്റർപ്രൈസ് SaaS ആപ്ലിക്കേഷൻ

യൂറോപ്പിൽ ആസ്ഥാനമായുള്ള നിങ്ങളുടെ കമ്പനി ഒരു SaaS ഉൽപ്പന്നം നൽകുന്നു. നിങ്ങളുടെ ക്ലയിന്റുകൾ വലിയ ആഗോള കോർപ്പറേഷനുകളാണ്, അവരിൽ പലരും സ്ഥിരതയ്ക്കായി പഴയ, ദീർഘകാല സപ്പോർട്ട് (LTS) പതിപ്പുകൾ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെയും പൈത്തണിന്റെയും ഉപയോഗിക്കുന്നു.

• വെല്ലുവിളി: നിങ്ങളുടെ ഡെവലപ്‌മെന്റ് ടീം ആധുനിക ടൂളുകൾ ഉപയോഗിക്കുന്നു, എന്നാൽ നിങ്ങളുടെ ക്ലയിന്റ് ലൈബ്രറി പഴയ എന്റർപ്രൈസ് എൻവയൺമെന്റുകളുമായി ബാക്ക്വേർഡ് കോംപാറ്റിബിൾ ആയിരിക്കണം.
• Tox പരിഹാരം: envlist = py38, py39, py310, py311 നിങ്ങളുടെ `tox.ini` എല്ലാ ടെസ്റ്റുകളും പൈത്തൺ 3.8-നെതിരെ വിജയിക്കുന്നുവെന്ന് ഉറപ്പാക്കുന്നു, ഇത് വടക്കേ അമേരിക്കയിലെ ഒരു പ്രധാന ക്ലയിന്റിന്റെ നിലവാരമായിരിക്കാം. CI-ൽ ഇത് സ്വയമേവ പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ, പുതിയ പൈത്തൺ പതിപ്പുകളിൽ മാത്രം ലഭ്യമായ വാക്യഘടനയോ ലൈബ്രറികളോ ഉപയോഗിക്കുന്ന ഫീച്ചറുകൾ ഡെവലപ്പർമാർ അറിയാതെ അവതരിപ്പിക്കുന്നതിൽ നിന്ന് നിങ്ങൾ തടയുന്നു, ഇത് ചെലവേറിയ ഡെപ്ലോയ്‌മെന്റ് പരാജയങ്ങൾ ഒഴിവാക്കുന്നു.

ഉപസംഹാരം: ആഗോള ആത്മവിശ്വാസത്തോടെ പുറത്തിറക്കുക

മൾട്ടി-എൻവയൺമെന്റ് ടെസ്റ്റിംഗ് ഇനി ഒരു ആഢംബരമല്ല; ഉയർന്ന നിലവാരമുള്ള, പ്രൊഫഷണൽ സോഫ്റ്റ്‌വെയർ വികസിപ്പിക്കുന്നതിനുള്ള ഒരു അടിസ്ഥാന രീതിയാണിത്. Tox ഉപയോഗിച്ച് ഓട്ടോമേഷൻ സ്വീകരിക്കുന്നതിലൂടെ, ഈ സങ്കീർണ്ണമായ വെല്ലുവിളിയെ ലളിതവും ആവർത്തിക്കാവുന്നതുമായ ഒരു പ്രക്രിയയാക്കി മാറ്റുന്നു.

ഒരൊറ്റ tox.ini ഫയലിൽ നിങ്ങളുടെ പിന്തുണയ്ക്കുന്ന എൻവയൺമെന്റുകൾ നിർവചിക്കുന്നതിലൂടെയും CI/CD പൈപ്പ്ലൈനുമായി സംയോജിപ്പിക്കുന്നതിലൂടെയും, നിങ്ങൾ ശക്തമായ ഒരു ക്വാളിറ്റി ഗേറ്റ് ഉണ്ടാക്കുന്നു. ഈ ഗേറ്റ് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ ശക്തവും, അനുയോജ്യവുമാണെന്നും, വ്യത്യസ്തവും ആഗോളവുമായ പ്രേക്ഷകർക്കായി തയ്യാറാണെന്നും ഉറപ്പാക്കുന്നു. ഭയങ്കരമായ "ഇത് എന്റെ മെഷീനിൽ പ്രവർത്തിക്കുന്നു" എന്നതിനെക്കുറിച്ച് വിഷമിക്കുന്നത് നിങ്ങൾക്ക് നിർത്താം, കൂടാതെ ലോകത്ത് എവിടെയായിരുന്നാലും എല്ലാവരുടെയും മെഷീനിൽ ഇത് പ്രവർത്തിക്കുമെന്ന ആത്മവിശ്വാസത്തോടെ കോഡ് പുറത്തിറക്കാൻ തുടങ്ങാം.